home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2002 #11 / Amiga Plus CD - 2002 - No. 11.iso / Tools / Development / libogg / libogg-1.0rc3 / src / framing.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-10-27  |  48.3 KB  |  1,741 lines
  1. /********************************************************************
  2.  *                                                                  *
  3.  * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE.   *
  4.  * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
  5.  * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
  6.  * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
  7.  *                                                                  *
  8.  * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2001             *
  9.  * by the XIPHOPHORUS Company http://www.xiph.org/                  *
  10.  *                                                                  *
  11.  ********************************************************************
  12.  
  13.  function: code raw [Vorbis] packets into framed OggSquish stream and
  14.            decode Ogg streams back into raw packets
  15.  last mod: $Id: framing.c,v 1.20 2001/12/20 00:58:45 segher Exp $
  16.  
  17.  note: The CRC code is directly derived from public domain code by
  18.  Ross Williams (ross@guest.adelaide.edu.au).  See docs/framing.html
  19.  for details.
  20.  
  21.  ********************************************************************/
  22.  
  23. #include <stdlib.h>
  24. #include <string.h>
  25. #include <ogg/ogg.h>
  26.  
  27. /* A complete description of Ogg framing exists in docs/framing.html */
  28.  
  29. int ogg_page_version(ogg_page *og){
  30.   return((int)(og->header[4]));
  31. }
  32.  
  33. int ogg_page_continued(ogg_page *og){
  34.   return((int)(og->header[5]&0x01));
  35. }
  36.  
  37. int ogg_page_bos(ogg_page *og){
  38.   return((int)(og->header[5]&0x02));
  39. }
  40.  
  41. int ogg_page_eos(ogg_page *og){
  42.   return((int)(og->header[5]&0x04));
  43. }
  44.  
  45. ogg_int64_t ogg_page_granulepos(ogg_page *og){
  46.   unsigned char *page=og->header;
  47.   ogg_int64_t granulepos=page[13]&(0xff);
  48.   granulepos= (granulepos<<8)|(page[12]&0xff);
  49.   granulepos= (granulepos<<8)|(page[11]&0xff);
  50.   granulepos= (granulepos<<8)|(page[10]&0xff);
  51.   granulepos= (granulepos<<8)|(page[9]&0xff);
  52.   granulepos= (granulepos<<8)|(page[8]&0xff);
  53.   granulepos= (granulepos<<8)|(page[7]&0xff);
  54.   granulepos= (granulepos<<8)|(page[6]&0xff);
  55.   return(granulepos);
  56. }
  57.  
  58. int ogg_page_serialno(ogg_page *og){
  59.   return(og->header[14] |
  60.      (og->header[15]<<8) |
  61.      (og->header[16]<<16) |
  62.      (og->header[17]<<24));
  63. }
  64.  
  65. long ogg_page_pageno(ogg_page *og){
  66.   return(og->header[18] |
  67.      (og->header[19]<<8) |
  68.      (og->header[20]<<16) |
  69.      (og->header[21]<<24));
  70. }
  71.  
  72.  
  73.  
  74. /* returns the number of packets that are completed on this page (if
  75.    the leading packet is begun on a previous page, but ends on this
  76.    page, it's counted */
  77.  
  78. /* NOTE:
  79. If a page consists of a packet begun on a previous page, and a new
  80. packet begun (but not completed) on this page, the return will be:
  81.   ogg_page_packets(page)   ==1, 
  82.   ogg_page_continued(page) !=0
  83.  
  84. If a page happens to be a single packet that was begun on a
  85. previous page, and spans to the next page (in the case of a three or
  86. more page packet), the return will be: 
  87.   ogg_page_packets(page)   ==0, 
  88.   ogg_page_continued(page) !=0
  89. */
  90.  
  91. int ogg_page_packets(ogg_page *og){
  92.   int i,n=og->header[26],count=0;
  93.   for(i=0;i<n;i++)
  94.     if(og->header[27+i]<255)count++;
  95.   return(count);
  96. }
  97.  
  98.  
  99. #if 0
  100. /* helper to initialize lookup for direct-table CRC (illustrative; we
  101.    use the static init below) */
  102.  
  103. static ogg_uint32_t _ogg_crc_entry(unsigned long index){
  104.   int           i;
  105.   unsigned long r;
  106.  
  107.   r = index << 24;
  108.   for (i=0; i<8; i++)
  109.     if (r & 0x80000000UL)
  110.       r = (r << 1) ^ 0x04c11db7; /* The same as the ethernet generator
  111.                     polynomial, although we use an
  112.                     unreflected alg and an init/final
  113.                     of 0, not 0xffffffff */
  114.     else
  115.        r<<=1;
  116.  return (r & 0xffffffffUL);
  117. }
  118. #endif
  119.  
  120. static ogg_uint32_t crc_lookup[256]={
  121.   0x00000000,0x04c11db7,0x09823b6e,0x0d4326d9,
  122.   0x130476dc,0x17c56b6b,0x1a864db2,0x1e475005,
  123.   0x2608edb8,0x22c9f00f,0x2f8ad6d6,0x2b4bcb61,
  124.   0x350c9b64,0x31cd86d3,0x3c8ea00a,0x384fbdbd,
  125.   0x4c11db70,0x48d0c6c7,0x4593e01e,0x4152fda9,
  126.   0x5f15adac,0x5bd4b01b,0x569796c2,0x52568b75,
  127.   0x6a1936c8,0x6ed82b7f,0x639b0da6,0x675a1011,
  128.   0x791d4014,0x7ddc5da3,0x709f7b7a,0x745e66cd,
  129.   0x9823b6e0,0x9ce2ab57,0x91a18d8e,0x95609039,
  130.   0x8b27c03c,0x8fe6dd8b,0x82a5fb52,0x8664e6e5,
  131.   0xbe2b5b58,0xbaea46ef,0xb7a96036,0xb3687d81,
  132.   0xad2f2d84,0xa9ee3033,0xa4ad16ea,0xa06c0b5d,
  133.   0xd4326d90,0xd0f37027,0xddb056fe,0xd9714b49,
  134.   0xc7361b4c,0xc3f706fb,0xceb42022,0xca753d95,
  135.   0xf23a8028,0xf6fb9d9f,0xfbb8bb46,0xff79a6f1,
  136.   0xe13ef6f4,0xe5ffeb43,0xe8bccd9a,0xec7dd02d,
  137.   0x34867077,0x30476dc0,0x3d044b19,0x39c556ae,
  138.   0x278206ab,0x23431b1c,0x2e003dc5,0x2ac12072,
  139.   0x128e9dcf,0x164f8078,0x1b0ca6a1,0x1fcdbb16,
  140.   0x018aeb13,0x054bf6a4,0x0808d07d,0x0cc9cdca,
  141.   0x7897ab07,0x7c56b6b0,0x71159069,0x75d48dde,
  142.   0x6b93dddb,0x6f52c06c,0x6211e6b5,0x66d0fb02,
  143.   0x5e9f46bf,0x5a5e5b08,0x571d7dd1,0x53dc6066,
  144.   0x4d9b3063,0x495a2dd4,0x44190b0d,0x40d816ba,
  145.   0xaca5c697,0xa864db20,0xa527fdf9,0xa1e6e04e,
  146.   0xbfa1b04b,0xbb60adfc,0xb6238b25,0xb2e29692,
  147.   0x8aad2b2f,0x8e6c3698,0x832f1041,0x87ee0df6,
  148.   0x99a95df3,0x9d684044,0x902b669d,0x94ea7b2a,
  149.   0xe0b41de7,0xe4750050,0xe9362689,0xedf73b3e,
  150.   0xf3b06b3b,0xf771768c,0xfa325055,0xfef34de2,
  151.   0xc6bcf05f,0xc27dede8,0xcf3ecb31,0xcbffd686,
  152.   0xd5b88683,0xd1799b34,0xdc3abded,0xd8fba05a,
  153.   0x690ce0ee,0x6dcdfd59,0x608edb80,0x644fc637,
  154.   0x7a089632,0x7ec98b85,0x738aad5c,0x774bb0eb,
  155.   0x4f040d56,0x4bc510e1,0x46863638,0x42472b8f,
  156.   0x5c007b8a,0x58c1663d,0x558240e4,0x51435d53,
  157.   0x251d3b9e,0x21dc2629,0x2c9f00f0,0x285e1d47,
  158.   0x36194d42,0x32d850f5,0x3f9b762c,0x3b5a6b9b,
  159.   0x0315d626,0x07d4cb91,0x0a97ed48,0x0e56f0ff,
  160.   0x1011a0fa,0x14d0bd4d,0x19939b94,0x1d528623,
  161.   0xf12f560e,0xf5ee4bb9,0xf8ad6d60,0xfc6c70d7,
  162.   0xe22b20d2,0xe6ea3d65,0xeba91bbc,0xef68060b,
  163.   0xd727bbb6,0xd3e6a601,0xdea580d8,0xda649d6f,
  164.   0xc423cd6a,0xc0e2d0dd,0xcda1f604,0xc960ebb3,
  165.   0xbd3e8d7e,0xb9ff90c9,0xb4bcb610,0xb07daba7,
  166.   0xae3afba2,0xaafbe615,0xa7b8c0cc,0xa379dd7b,
  167.   0x9b3660c6,0x9ff77d71,0x92b45ba8,0x9675461f,
  168.   0x8832161a,0x8cf30bad,0x81b02d74,0x857130c3,
  169.   0x5d8a9099,0x594b8d2e,0x5408abf7,0x50c9b640,
  170.   0x4e8ee645,0x4a4ffbf2,0x470cdd2b,0x43cdc09c,
  171.   0x7b827d21,0x7f436096,0x7200464f,0x76c15bf8,
  172.   0x68860bfd,0x6c47164a,0x61043093,0x65c52d24,
  173.   0x119b4be9,0x155a565e,0x18197087,0x1cd86d30,
  174.   0x029f3d35,0x065e2082,0x0b1d065b,0x0fdc1bec,
  175.   0x3793a651,0x3352bbe6,0x3e119d3f,0x3ad08088,
  176.   0x2497d08d,0x2056cd3a,0x2d15ebe3,0x29d4f654,
  177.   0xc5a92679,0xc1683bce,0xcc2b1d17,0xc8ea00a0,
  178.   0xd6ad50a5,0xd26c4d12,0xdf2f6bcb,0xdbee767c,
  179.   0xe3a1cbc1,0xe760d676,0xea23f0af,0xeee2ed18,
  180.   0xf0a5bd1d,0xf464a0aa,0xf9278673,0xfde69bc4,
  181.   0x89b8fd09,0x8d79e0be,0x803ac667,0x84fbdbd0,
  182.   0x9abc8bd5,0x9e7d9662,0x933eb0bb,0x97ffad0c,
  183.   0xafb010b1,0xab710d06,0xa6322bdf,0xa2f33668,
  184.   0xbcb4666d,0xb8757bda,0xb5365d03,0xb1f740b4};
  185.  
  186. /* init the encode/decode logical stream state */
  187.  
  188. int ogg_stream_init(ogg_stream_state *os,int serialno){
  189.   if(os){
  190.     memset(os,0,sizeof(*os));
  191.     os->body_storage=16*1024;
  192.     os->body_data=_ogg_malloc(os->body_storage*sizeof(*os->body_data));
  193.  
  194.     os->lacing_storage=1024;
  195.     os->lacing_vals=_ogg_malloc(os->lacing_storage*sizeof(*os->lacing_vals));
  196.     os->granule_vals=_ogg_malloc(os->lacing_storage*sizeof(*os->granule_vals));
  197.  
  198.     os->serialno=serialno;
  199.  
  200.     return(0);
  201.   }
  202.   return(-1);
  203. } 
  204.  
  205. /* _clear does not free os, only the non-flat storage within */
  206. int ogg_stream_clear(ogg_stream_state *os){
  207.   if(os){
  208.     if(os->body_data)_ogg_free(os->body_data);
  209.     if(os->lacing_vals)_ogg_free(os->lacing_vals);
  210.     if(os->granule_vals)_ogg_free(os->granule_vals);
  211.  
  212.     memset(os,0,sizeof(*os));    
  213.   }
  214.   return(0);
  215. } 
  216.  
  217. int ogg_stream_destroy(ogg_stream_state *os){
  218.   if(os){
  219.     ogg_stream_clear(os);
  220.     _ogg_free(os);
  221.   }
  222.   return(0);
  223. } 
  224.  
  225. /* Helpers for ogg_stream_encode; this keeps the structure and
  226.    what's happening fairly clear */
  227.  
  228. static void _os_body_expand(ogg_stream_state *os,int needed){
  229.   if(os->body_storage<=os->body_fill+needed){
  230.     os->body_storage+=(needed+1024);
  231.     os->body_data=_ogg_realloc(os->body_data,os->body_storage*sizeof(*os->body_data));
  232.   }
  233. }
  234.  
  235. static void _os_lacing_expand(ogg_stream_state *os,int needed){
  236.   if(os->lacing_storage<=os->lacing_fill+needed){
  237.     os->lacing_storage+=(needed+32);
  238.     os->lacing_vals=_ogg_realloc(os->lacing_vals,os->lacing_storage*sizeof(*os->lacing_vals));
  239.     os->granule_vals=_ogg_realloc(os->granule_vals,os->lacing_storage*sizeof(*os->granule_vals));
  240.   }
  241. }
  242.  
  243. /* checksum the page */
  244. /* Direct table CRC; note that this will be faster in the future if we
  245.    perform the checksum silmultaneously with other copies */
  246.  
  247. void ogg_page_checksum_set(ogg_page *og){
  248.   if(og){
  249.     ogg_uint32_t crc_reg=0;
  250.     int i;
  251.  
  252.     /* safety; needed for API behavior, but not framing code */
  253.     og->header[22]=0;
  254.     og->header[23]=0;
  255.     og->header[24]=0;
  256.     og->header[25]=0;
  257.     
  258.     for(i=0;i<og->header_len;i++)
  259.       crc_reg=(crc_reg<<8)^crc_lookup[((crc_reg >> 24)&0xff)^og->header[i]];
  260.     for(i=0;i<og->body_len;i++)
  261.       crc_reg=(crc_reg<<8)^crc_lookup[((crc_reg >> 24)&0xff)^og->body[i]];
  262.     
  263.     og->header[22]=crc_reg&0xff;
  264.     og->header[23]=(crc_reg>>8)&0xff;
  265.     og->header[24]=(crc_reg>>16)&0xff;
  266.     og->header[25]=(crc_reg>>24)&0xff;
  267.   }
  268. }
  269.  
  270. /* submit data to the internal buffer of the framing engine */
  271. int ogg_stream_packetin(ogg_stream_state *os,ogg_packet *op){
  272.   int lacing_vals=op->bytes/255+1,i;
  273.  
  274.   if(os->body_returned){
  275.     /* advance packet data according to the body_returned pointer. We
  276.        had to keep it around to return a pointer into the buffer last
  277.        call */
  278.     
  279.     os->body_fill-=os->body_returned;
  280.     if(os->body_fill)
  281.       memmove(os->body_data,os->body_data+os->body_returned,
  282.           os->body_fill);
  283.     os->body_returned=0;
  284.   }
  285.  
  286.   /* make sure we have the buffer storage */
  287.   _os_body_expand(os,op->bytes);
  288.   _os_lacing_expand(os,lacing_vals);
  289.  
  290.   /* Copy in the submitted packet.  Yes, the copy is a waste; this is
  291.      the liability of overly clean abstraction for the time being.  It
  292.      will actually be fairly easy to eliminate the extra copy in the
  293.      future */
  294.  
  295.   memcpy(os->body_data+os->body_fill,op->packet,op->bytes);
  296.   os->body_fill+=op->bytes;
  297.  
  298.   /* Store lacing vals for this packet */
  299.   for(i=0;i<lacing_vals-1;i++){
  300.     os->lacing_vals[os->lacing_fill+i]=255;
  301.     os->granule_vals[os->lacing_fill+i]=os->granulepos;
  302.   }
  303.   os->lacing_vals[os->lacing_fill+i]=(op->bytes)%255;
  304.   os->granulepos=os->granule_vals[os->lacing_fill+i]=op->granulepos;
  305.  
  306.   /* flag the first segment as the beginning of the packet */
  307.   os->lacing_vals[os->lacing_fill]|= 0x100;
  308.  
  309.   os->lacing_fill+=lacing_vals;
  310.  
  311.   /* for the sake of completeness */
  312.   os->packetno++;
  313.  
  314.   if(op->e_o_s)os->e_o_s=1;
  315.  
  316.   return(0);
  317. }
  318.  
  319. /* This will flush remaining packets into a page (returning nonzero),
  320.    even if there is not enough data to trigger a flush normally
  321.    (undersized page). If there are no packets or partial packets to
  322.    flush, ogg_stream_flush returns 0.  Note that ogg_stream_flush will
  323.    try to flush a normal sized page like ogg_stream_pageout; a call to
  324.    ogg_stream_flush does not gurantee that all packets have flushed.
  325.    Only a return value of 0 from ogg_stream_flush indicates all packet
  326.    data is flushed into pages.
  327.  
  328.    ogg_stream_page will flush the last page in a stream even if it's
  329.    undersized; you almost certainly want to use ogg_stream_pageout
  330.    (and *not* ogg_stream_flush) unless you need to flush an undersized
  331.    page in the middle of a stream for some reason. */
  332.  
  333. int ogg_stream_flush(ogg_stream_state *os,ogg_page *og){
  334.   int i;
  335.   int vals=0;
  336.   int maxvals=(os->lacing_fill>255?255:os->lacing_fill);
  337.   int bytes=0;
  338.   long acc=0;
  339.   ogg_int64_t granule_pos=os->granule_vals[0];
  340.  
  341.   if(maxvals==0)return(0);
  342.   
  343.   /* construct a page */
  344.   /* decide how many segments to include */
  345.   
  346.   /* If this is the initial header case, the first page must only include
  347.      the initial header packet */
  348.   if(os->b_o_s==0){  /* 'initial header page' case */
  349.     granule_pos=0;
  350.     for(vals=0;vals<maxvals;vals++){
  351.       if((os->lacing_vals[vals]&0x0ff)<255){
  352.     vals++;
  353.     break;
  354.       }
  355.     }
  356.   }else{
  357.     for(vals=0;vals<maxvals;vals++){
  358.       if(acc>4096)break;
  359.       acc+=os->lacing_vals[vals]&0x0ff;
  360.       granule_pos=os->granule_vals[vals];
  361.     }
  362.   }
  363.   
  364.   /* construct the header in temp storage */
  365.   memcpy(os->header,"OggS",4);
  366.   
  367.   /* stream structure version */
  368.   os->header[4]=0x00;
  369.   
  370.   /* continued packet flag? */
  371.   os->header[5]=0x00;
  372.   if((os->lacing_vals[0]&0x100)==0)os->header[5]|=0x01;
  373.   /* first page flag? */
  374.   if(os->b_o_s==0)os->header[5]|=0x02;
  375.   /* last page flag? */
  376.   if(os->e_o_s && os->lacing_fill==vals)os->header[5]|=0x04;
  377.   os->b_o_s=1;
  378.  
  379.   /* 64 bits of PCM position */
  380.   for(i=6;i<14;i++){
  381.     os->header[i]=(granule_pos&0xff);
  382.     granule_pos>>=8;
  383.   }
  384.  
  385.   /* 32 bits of stream serial number */
  386.   {
  387.     long serialno=os->serialno;
  388.     for(i=14;i<18;i++){
  389.       os->header[i]=(serialno&0xff);
  390.       serialno>>=8;
  391.     }
  392.   }
  393.  
  394.   /* 32 bits of page counter (we have both counter and page header
  395.      because this val can roll over) */
  396.   if(os->pageno==-1)os->pageno=0; /* because someone called
  397.                      stream_reset; this would be a
  398.                      strange thing to do in an
  399.                      encode stream, but it has
  400.                      plausible uses */
  401.   {
  402.     long pageno=os->pageno++;
  403.     for(i=18;i<22;i++){
  404.       os->header[i]=(pageno&0xff);
  405.       pageno>>=8;
  406.     }
  407.   }
  408.   
  409.   /* zero for computation; filled in later */
  410.   os->header[22]=0;
  411.   os->header[23]=0;
  412.   os->header[24]=0;
  413.   os->header[25]=0;
  414.   
  415.   /* segment table */
  416.   os->header[26]=vals&0xff;
  417.   for(i=0;i<vals;i++)
  418.     bytes+=os->header[i+27]=(os->lacing_vals[i]&0xff);
  419.   
  420.   /* set pointers in the ogg_page struct */
  421.   og->header=os->header;
  422.   og->header_len=os->header_fill=vals+27;
  423.   og->body=os->body_data+os->body_returned;
  424.   og->body_len=bytes;
  425.   
  426.   /* advance the lacing data and set the body_returned pointer */
  427.   
  428.   os->lacing_fill-=vals;
  429.   memmove(os->lacing_vals,os->lacing_vals+vals,os->lacing_fill*sizeof(*os->lacing_vals));
  430.   memmove(os->granule_vals,os->granule_vals+vals,os->lacing_fill*sizeof(*os->granule_vals));
  431.   os->body_returned+=bytes;
  432.   
  433.   /* calculate the checksum */
  434.   
  435.   ogg_page_checksum_set(og);
  436.  
  437.   /* done */
  438.   return(1);
  439. }
  440.  
  441.  
  442. /* This constructs pages from buffered packet segments.  The pointers
  443. returned are to static buffers; do not free. The returned buffers are
  444. good only until the next call (using the same ogg_stream_state) */
  445.  
  446. int ogg_stream_pageout(ogg_stream_state *os, ogg_page *og){
  447.  
  448.   if((os->e_o_s&&os->lacing_fill) ||          /* 'were done, now flush' case */
  449.      os->body_fill-os->body_returned > 4096 ||/* 'page nominal size' case */
  450.      os->lacing_fill>=255 ||                  /* 'segment table full' case */
  451.      (os->lacing_fill&&!os->b_o_s)){          /* 'initial header page' case */
  452.         
  453.     return(ogg_stream_flush(os,og));
  454.   }
  455.   
  456.   /* not enough data to construct a page and not end of stream */
  457.   return(0);
  458. }
  459.  
  460. int ogg_stream_eos(ogg_stream_state *os){
  461.   return os->e_o_s;
  462. }
  463.  
  464. /* DECODING PRIMITIVES: packet streaming layer **********************/
  465.  
  466. /* This has two layers to place more of the multi-serialno and paging
  467.    control in the application's hands.  First, we expose a data buffer
  468.    using ogg_sync_buffer().  The app either copies into the
  469.    buffer, or passes it directly to read(), etc.  We then call
  470.    ogg_sync_wrote() to tell how many bytes we just added.
  471.  
  472.    Pages are returned (pointers into the buffer in ogg_sync_state)
  473.    by ogg_sync_pageout().  The page is then submitted to
  474.    ogg_stream_pagein() along with the appropriate
  475.    ogg_stream_state* (ie, matching serialno).  We then get raw
  476.    packets out calling ogg_stream_packetout() with a
  477.    ogg_stream_state.  See the 'frame-prog.txt' docs for details and
  478.    example code. */
  479.  
  480. /* initialize the struct to a known state */
  481. int ogg_sync_init(ogg_sync_state *oy){
  482.   if(oy){
  483.     memset(oy,0,sizeof(*oy));
  484.   }
  485.   return(0);
  486. }
  487.  
  488. /* clear non-flat storage within */
  489. int ogg_sync_clear(ogg_sync_state *oy){
  490.   if(oy){
  491.     if(oy->data)_ogg_free(oy->data);
  492.     ogg_sync_init(oy);
  493.   }
  494.   return(0);
  495. }
  496.  
  497. int ogg_sync_destroy(ogg_sync_state *oy){
  498.   if(oy){
  499.     ogg_sync_clear(oy);
  500.     _ogg_free(oy);
  501.   }
  502.   return(0);
  503. }
  504.  
  505. char *ogg_sync_buffer(ogg_sync_state *oy, long size){
  506.  
  507.   /* first, clear out any space that has been previously returned */
  508.   if(oy->returned){
  509.     oy->fill-=oy->returned;
  510.     if(oy->fill>0)
  511.       memmove(oy->data,oy->data+oy->returned,oy->fill);
  512.     oy->returned=0;
  513.   }
  514.  
  515.   if(size>oy->storage-oy->fill){
  516.     /* We need to extend the internal buffer */
  517.     long newsize=size+oy->fill+4096; /* an extra page to be nice */
  518.  
  519.     if(oy->data)
  520.       oy->data=_ogg_realloc(oy->data,newsize);
  521.     else
  522.       oy->data=_ogg_malloc(newsize);
  523.     oy->storage=newsize;
  524.   }
  525.  
  526.   /* expose a segment at least as large as requested at the fill mark */
  527.   return((char *)oy->data+oy->fill);
  528. }
  529.  
  530. int ogg_sync_wrote(ogg_sync_state *oy, long bytes){
  531.   if(oy->fill+bytes>oy->storage)return(-1);
  532.   oy->fill+=bytes;
  533.   return(0);
  534. }
  535.  
  536. /* sync the stream.  This is meant to be useful for finding page
  537.    boundaries.
  538.  
  539.    return values for this:
  540.   -n) skipped n bytes
  541.    0) page not ready; more data (no bytes skipped)
  542.    n) page synced at current location; page length n bytes
  543.    
  544. */
  545.  
  546. long ogg_sync_pageseek(ogg_sync_state *oy,ogg_page *og){
  547.   unsigned char *page=oy->data+oy->returned;
  548.   unsigned char *next;
  549.   long bytes=oy->fill-oy->returned;
  550.   
  551.   if(oy->headerbytes==0){
  552.     int headerbytes,i;
  553.     if(bytes<27)return(0); /* not enough for a header */
  554.     
  555.     /* verify capture pattern */
  556.     if(memcmp(page,"OggS",4))goto sync_fail;
  557.     
  558.     headerbytes=page[26]+27;
  559.     if(bytes<headerbytes)return(0); /* not enough for header + seg table */
  560.     
  561.     /* count up body length in the segment table */
  562.     
  563.     for(i=0;i<page[26];i++)
  564.       oy->bodybytes+=page[27+i];
  565.     oy->headerbytes=headerbytes;
  566.   }
  567.   
  568.   if(oy->bodybytes+oy->headerbytes>bytes)return(0);
  569.   
  570.   /* The whole test page is buffered.  Verify the checksum */
  571.   {
  572.     /* Grab the checksum bytes, set the header field to zero */
  573.     char chksum[4];
  574.     ogg_page log;
  575.     
  576.     memcpy(chksum,page+22,4);
  577.     memset(page+22,0,4);
  578.     
  579.     /* set up a temp page struct and recompute the checksum */
  580.     log.header=page;
  581.     log.header_len=oy->headerbytes;
  582.     log.body=page+oy->headerbytes;
  583.     log.body_len=oy->bodybytes;
  584.     ogg_page_checksum_set(&log);
  585.     
  586.     /* Compare */
  587.     if(memcmp(chksum,page+22,4)){
  588.       /* D'oh.  Mismatch! Corrupt page (or miscapture and not a page
  589.      at all) */
  590.       /* replace the computed checksum with the one actually read in */
  591.       memcpy(page+22,chksum,4);
  592.       
  593.       /* Bad checksum. Lose sync */
  594.       goto sync_fail;
  595.     }
  596.   }
  597.   
  598.   /* yes, have a whole page all ready to go */
  599.   {
  600.     unsigned char *page=oy->data+oy->returned;
  601.     long bytes;
  602.  
  603.     if(og){
  604.       og->header=page;
  605.       og->header_len=oy->headerbytes;
  606.       og->body=page+oy->headerbytes;
  607.       og->body_len=oy->bodybytes;
  608.     }
  609.  
  610.     oy->unsynced=0;
  611.     oy->returned+=(bytes=oy->headerbytes+oy->bodybytes);
  612.     oy->headerbytes=0;
  613.     oy->bodybytes=0;
  614.     return(bytes);
  615.   }
  616.   
  617.  sync_fail:
  618.   
  619.   oy->headerbytes=0;
  620.   oy->bodybytes=0;
  621.   
  622.   /* search for possible capture */
  623.   next=memchr(page+1,'O',bytes-1);
  624.   if(!next)
  625.     next=oy->data+oy->fill;
  626.  
  627.   oy->returned=next-oy->data;
  628.   return(-(next-page));
  629. }
  630.  
  631. /* sync the stream and get a page.  Keep trying until we find a page.
  632.    Supress 'sync errors' after reporting the first.
  633.  
  634.    return values:
  635.    -1) recapture (hole in data)
  636.     0) need more data
  637.     1) page returned
  638.  
  639.    Returns pointers into buffered data; invalidated by next call to
  640.    _stream, _clear, _init, or _buffer */
  641.  
  642. int ogg_sync_pageout(ogg_sync_state *oy, ogg_page *og){
  643.  
  644.   /* all we need to do is verify a page at the head of the stream
  645.      buffer.  If it doesn't verify, we look for the next potential
  646.      frame */
  647.  
  648.   while(1){
  649.     long ret=ogg_sync_pageseek(oy,og);
  650.     if(ret>0){
  651.       /* have a page */
  652.       return(1);
  653.     }
  654.     if(ret==0){
  655.       /* need more data */
  656.       return(0);
  657.     }
  658.     
  659.     /* head did not start a synced page... skipped some bytes */
  660.     if(!oy->unsynced){
  661.       oy->unsynced=1;
  662.       return(-1);
  663.     }
  664.  
  665.     /* loop. keep looking */
  666.  
  667.   }
  668. }
  669.  
  670. /* add the incoming page to the stream state; we decompose the page
  671.    into packet segments here as well. */
  672.  
  673. int ogg_stream_pagein(ogg_stream_state *os, ogg_page *og){
  674.   unsigned char *header=og->header;
  675.   unsigned char *body=og->body;
  676.   long           bodysize=og->body_len;
  677.   int            segptr=0;
  678.  
  679.   int version=ogg_page_version(og);
  680.   int continued=ogg_page_continued(og);
  681.   int bos=ogg_page_bos(og);
  682.   int eos=ogg_page_eos(og);
  683.   ogg_int64_t granulepos=ogg_page_granulepos(og);
  684.   int serialno=ogg_page_serialno(og);
  685.   long pageno=ogg_page_pageno(og);
  686.   int segments=header[26];
  687.   
  688.   /* clean up 'returned data' */
  689.   {
  690.     long lr=os->lacing_returned;
  691.     long br=os->body_returned;
  692.  
  693.     /* body data */
  694.     if(br){
  695.       os->body_fill-=br;
  696.       if(os->body_fill)
  697.     memmove(os->body_data,os->body_data+br,os->body_fill);
  698.       os->body_returned=0;
  699.     }
  700.  
  701.     if(lr){
  702.       /* segment table */
  703.       if(os->lacing_fill-lr){
  704.     memmove(os->lacing_vals,os->lacing_vals+lr,
  705.         (os->lacing_fill-lr)*sizeof(*os->lacing_vals));
  706.     memmove(os->granule_vals,os->granule_vals+lr,
  707.         (os->lacing_fill-lr)*sizeof(*os->granule_vals));
  708.       }
  709.       os->lacing_fill-=lr;
  710.       os->lacing_packet-=lr;
  711.       os->lacing_returned=0;
  712.     }
  713.   }
  714.  
  715.   /* check the serial number */
  716.   if(serialno!=os->serialno)return(-1);
  717.   if(version>0)return(-1);
  718.  
  719.   _os_lacing_expand(os,segments+1);
  720.  
  721.   /* are we in sequence? */
  722.   if(pageno!=os->pageno){
  723.     int i;
  724.  
  725.     /* unroll previous partial packet (if any) */
  726.     for(i=os->lacing_packet;i<os->lacing_fill;i++)
  727.       os->body_fill-=os->lacing_vals[i]&0xff;
  728.     os->lacing_fill=os->lacing_packet;
  729.  
  730.     /* make a note of dropped data in segment table */
  731.     if(os->pageno!=-1){
  732.       os->lacing_vals[os->lacing_fill++]=0x400;
  733.       os->lacing_packet++;
  734.     }
  735.  
  736.     /* are we a 'continued packet' page?  If so, we'll need to skip
  737.        some segments */
  738.     if(continued){
  739.       bos=0;
  740.       for(;segptr<segments;segptr++){
  741.     int val=header[27+segptr];
  742.     body+=val;
  743.     bodysize-=val;
  744.     if(val<255){
  745.       segptr++;
  746.       break;
  747.     }
  748.       }
  749.     }
  750.   }
  751.   
  752.   if(bodysize){
  753.     _os_body_expand(os,bodysize);
  754.     memcpy(os->body_data+os->body_fill,body,bodysize);
  755.     os->body_fill+=bodysize;
  756.   }
  757.  
  758.   {
  759.     int saved=-1;
  760.     while(segptr<segments){
  761.       int val=header[27+segptr];
  762.       os->lacing_vals[os->lacing_fill]=val;
  763.       os->granule_vals[os->lacing_fill]=-1;
  764.       
  765.       if(bos){
  766.     os->lacing_vals[os->lacing_fill]|=0x100;
  767.     bos=0;
  768.       }
  769.       
  770.       if(val<255)saved=os->lacing_fill;
  771.       
  772.       os->lacing_fill++;
  773.       segptr++;
  774.       
  775.       if(val<255)os->lacing_packet=os->lacing_fill;
  776.     }
  777.   
  778.     /* set the granulepos on the last granuleval of the last full packet */
  779.     if(saved!=-1){
  780.       os->granule_vals[saved]=granulepos;
  781.     }
  782.  
  783.   }
  784.  
  785.   if(eos){
  786.     os->e_o_s=1;
  787.     if(os->lacing_fill>0)
  788.       os->lacing_vals[os->lacing_fill-1]|=0x200;
  789.   }
  790.  
  791.   os->pageno=pageno+1;
  792.  
  793.   return(0);
  794. }
  795.  
  796. /* clear things to an initial state.  Good to call, eg, before seeking */
  797. int ogg_sync_reset(ogg_sync_state *oy){
  798.   oy->fill=0;
  799.   oy->returned=0;
  800.   oy->unsynced=0;
  801.   oy->headerbytes=0;
  802.   oy->bodybytes=0;
  803.   return(0);
  804. }
  805.  
  806. int ogg_stream_reset(ogg_stream_state *os){
  807.   os->body_fill=0;
  808.   os->body_returned=0;
  809.  
  810.   os->lacing_fill=0;
  811.   os->lacing_packet=0;
  812.   os->lacing_returned=0;
  813.  
  814.   os->header_fill=0;
  815.  
  816.   os->e_o_s=0;
  817.   os->b_o_s=0;
  818.   os->pageno=-1;
  819.   os->packetno=0;
  820.   os->granulepos=0;
  821.  
  822.   return(0);
  823. }
  824.  
  825. static int _packetout(ogg_stream_state *os,ogg_packet *op,int adv){
  826.  
  827.   /* The last part of decode. We have the stream broken into packet
  828.      segments.  Now we need to group them into packets (or return the
  829.      out of sync markers) */
  830.  
  831.   int ptr=os->lacing_returned;
  832.  
  833.   if(os->lacing_packet<=ptr)return(0);
  834.  
  835.   if(os->lacing_vals[ptr]&0x400){
  836.     /* we need to tell the codec there's a gap; it might need to
  837.        handle previous packet dependencies. */
  838.     os->lacing_returned++;
  839.     os->packetno++;
  840.     return(-1);
  841.   }
  842.  
  843.   if(!op && !adv)return(1); /* just using peek as an inexpensive way
  844.                                to ask if there's a whole packet
  845.                                waiting */
  846.  
  847.   /* Gather the whole packet. We'll have no holes or a partial packet */
  848.   {
  849.     int size=os->lacing_vals[ptr]&0xff;
  850.     int bytes=size;
  851.     int eos=os->lacing_vals[ptr]&0x200; /* last packet of the stream? */
  852.     int bos=os->lacing_vals[ptr]&0x100; /* first packet of the stream? */
  853.  
  854.     while(size==255){
  855.       int val=os->lacing_vals[++ptr];
  856.       size=val&0xff;
  857.       if(val&0x200)eos=0x200;
  858.       bytes+=size;
  859.     }
  860.  
  861.     if(op){
  862.       op->e_o_s=eos;
  863.       op->b_o_s=bos;
  864.       op->packet=os->body_data+os->body_returned;
  865.       op->packetno=os->packetno;
  866.       op->granulepos=os->granule_vals[ptr];
  867.       op->bytes=bytes;
  868.     }
  869.  
  870.     if(adv){
  871.       os->body_returned+=bytes;
  872.       os->lacing_returned=ptr+1;
  873.       os->packetno++;
  874.     }
  875.   }
  876.   return(1);
  877. }
  878.  
  879. int ogg_stream_packetout(ogg_stream_state *os,ogg_packet *op){
  880.   return _packetout(os,op,1);
  881. }
  882.  
  883. int ogg_stream_packetpeek(ogg_stream_state *os,ogg_packet *op){
  884.   return _packetout(os,op,0);
  885. }
  886.  
  887. void ogg_packet_clear(ogg_packet *op) {
  888.   _ogg_free(op->packet);
  889.   memset(op, 0, sizeof(*op));
  890. }
  891.  
  892. #ifdef _V_SELFTEST
  893. #include <stdio.h>
  894.  
  895. ogg_stream_state os_en, os_de;
  896. ogg_sync_state oy;
  897.  
  898. void checkpacket(ogg_packet *op,int len, int no, int pos){
  899.   long j;
  900.   static int sequence=0;
  901.   static int lastno=0;
  902.  
  903.   if(op->bytes!=len){
  904.     fprintf(stderr,"incorrect packet length!\n");
  905.     exit(1);
  906.   }
  907.   if(op->granulepos!=pos){
  908.     fprintf(stderr,"incorrect packet position!\n");
  909.     exit(1);
  910.   }
  911.  
  912.   /* packet number just follows sequence/gap; adjust the input number
  913.      for that */
  914.   if(no==0){
  915.     sequence=0;
  916.   }else{
  917.     sequence++;
  918.     if(no>lastno+1)
  919.       sequence++;
  920.   }
  921.   lastno=no;
  922.   if(op->packetno!=sequence){
  923.     fprintf(stderr,"incorrect packet sequence %ld != %d\n",
  924.         (long)(op->packetno),sequence);
  925.     exit(1);
  926.   }
  927.  
  928.   /* Test data */
  929.   for(j=0;j<op->bytes;j++)
  930.     if(op->packet[j]!=((j+no)&0xff)){
  931.       fprintf(stderr,"body data mismatch (1) at pos %ld: %x!=%lx!\n\n",
  932.           j,op->packet[j],(j+no)&0xff);
  933.       exit(1);
  934.     }
  935. }
  936.  
  937. void check_page(unsigned char *data,const int *header,ogg_page *og){
  938.   long j;
  939.   /* Test data */
  940.   for(j=0;j<og->body_len;j++)
  941.     if(og->body[j]!=data[j]){
  942.       fprintf(stderr,"body data mismatch (2) at pos %ld: %x!=%x!\n\n",
  943.           j,data[j],og->body[j]);
  944.       exit(1);
  945.     }
  946.  
  947.   /* Test header */
  948.   for(j=0;j<og->header_len;j++){
  949.     if(og->header[j]!=header[j]){
  950.       fprintf(stderr,"header content mismatch at pos %ld:\n",j);
  951.       for(j=0;j<header[26]+27;j++)
  952.     fprintf(stderr," (%ld)%02x:%02x",j,header[j],og->header[j]);
  953.       fprintf(stderr,"\n");
  954.       exit(1);
  955.     }
  956.   }
  957.   if(og->header_len!=header[26]+27){
  958.     fprintf(stderr,"header length incorrect! (%ld!=%d)\n",
  959.         og->header_len,header[26]+27);
  960.     exit(1);
  961.   }
  962. }
  963.  
  964. void print_header(ogg_page *og){
  965.   int j;
  966.   fprintf(stderr,"\nHEADER:\n");
  967.   fprintf(stderr,"  capture: %c %c %c %c  version: %d  flags: %x\n",
  968.       og->header[0],og->header[1],og->header[2],og->header[3],
  969.       (int)og->header[4],(int)og->header[5]);
  970.  
  971.   fprintf(stderr,"  granulepos: %d  serialno: %d  pageno: %ld\n",
  972.       (og->header[9]<<24)|(og->header[8]<<16)|
  973.       (og->header[7]<<8)|og->header[6],
  974.       (og->header[17]<<24)|(og->header[16]<<16)|
  975.       (og->header[15]<<8)|og->header[14],
  976.       ((long)(og->header[21])<<24)|(og->header[20]<<16)|
  977.       (og->header[19]<<8)|og->header[18]);
  978.  
  979.   fprintf(stderr,"  checksum: %02x:%02x:%02x:%02x\n  segments: %d (",
  980.       (int)og->header[22],(int)og->header[23],
  981.       (int)og->header[24],(int)og->header[25],
  982.       (int)og->header[26]);
  983.  
  984.   for(j=27;j<og->header_len;j++)
  985.     fprintf(stderr,"%d ",(int)og->header[j]);
  986.   fprintf(stderr,")\n\n");
  987. }
  988.  
  989. void copy_page(ogg_page *og){
  990.   unsigned char *temp=_ogg_malloc(og->header_len);
  991.   memcpy(temp,og->header,og->header_len);
  992.   og->header=temp;
  993.  
  994.   temp=_ogg_malloc(og->body_len);
  995.   memcpy(temp,og->body,og->body_len);
  996.   og->body=temp;
  997. }
  998.  
  999. void error(void){
  1000.   fprintf(stderr,"error!\n");
  1001.   exit(1);
  1002. }
  1003.  
  1004. /* 17 only */
  1005. const int head1_0[] = {0x4f,0x67,0x67,0x53,0,0x06,
  1006.                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  1007.                0x01,0x02,0x03,0x04,0,0,0,0,
  1008.                0x15,0xed,0xec,0x91,
  1009.                1,
  1010.                17};
  1011.  
  1012. /* 17, 254, 255, 256, 500, 510, 600 byte, pad */
  1013. const int head1_1[] = {0x4f,0x67,0x67,0x53,0,0x02,
  1014.                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  1015.                0x01,0x02,0x03,0x04,0,0,0,0,
  1016.                0x59,0x10,0x6c,0x2c,
  1017.                1,
  1018.                17};
  1019. const int head2_1[] = {0x4f,0x67,0x67,0x53,0,0x04,
  1020.                0x07,0x18,0x00,0x00,0x00,0x00,0x00,0x00,
  1021.                0x01,0x02,0x03,0x04,1,0,0,0,
  1022.                0x89,0x33,0x85,0xce,
  1023.                13,
  1024.                254,255,0,255,1,255,245,255,255,0,
  1025.                255,255,90};
  1026.  
  1027. /* nil packets; beginning,middle,end */
  1028. const int head1_2[] = {0x4f,0x67,0x67,0x53,0,0x02,
  1029.                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  1030.                0x01,0x02,0x03,0x04,0,0,0,0,
  1031.                0xff,0x7b,0x23,0x17,
  1032.                1,
  1033.                0};
  1034. const int head2_2[] = {0x4f,0x67,0x67,0x53,0,0x04,
  1035.                0x07,0x28,0x00,0x00,0x00,0x00,0x00,0x00,
  1036.                0x01,0x02,0x03,0x04,1,0,0,0,
  1037.                0x5c,0x3f,0x66,0xcb,
  1038.                17,
  1039.                17,254,255,0,0,255,1,0,255,245,255,255,0,
  1040.                255,255,90,0};
  1041.  
  1042. /* large initial packet */
  1043. const int head1_3[] = {0x4f,0x67,0x67,0x53,0,0x02,
  1044.                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  1045.                0x01,0x02,0x03,0x04,0,0,0,0,
  1046.                0x01,0x27,0x31,0xaa,
  1047.                18,
  1048.                255,255,255,255,255,255,255,255,
  1049.                255,255,255,255,255,255,255,255,255,10};
  1050.  
  1051. const int head2_3[] = {0x4f,0x67,0x67,0x53,0,0x04,
  1052.                0x07,0x08,0x00,0x00,0x00,0x00,0x00,0x00,
  1053.                0x01,0x02,0x03,0x04,1,0,0,0,
  1054.                0x7f,0x4e,0x8a,0xd2,
  1055.                4,
  1056.                255,4,255,0};
  1057.  
  1058.  
  1059. /* continuing packet test */
  1060. const int head1_4[] = {0x4f,0x67,0x67,0x53,0,0x02,
  1061.                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  1062.                0x01,0x02,0x03,0x04,0,0,0,0,
  1063.                0xff,0x7b,0x23,0x17,
  1064.                1,
  1065.                0};
  1066.  
  1067. const int head2_4[] = {0x4f,0x67,0x67,0x53,0,0x00,
  1068.                0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  1069.                0x01,0x02,0x03,0x04,1,0,0,0,
  1070.                0x34,0x24,0xd5,0x29,
  1071.                17,
  1072.                255,255,255,255,255,255,255,255,
  1073.                255,255,255,255,255,255,255,255,255};
  1074.  
  1075. const int head3_4[] = {0x4f,0x67,0x67,0x53,0,0x05,
  1076.                0x07,0x0c,0x00,0x00,0x00,0x00,0x00,0x00,
  1077.                0x01,0x02,0x03,0x04,2,0,0,0,
  1078.                0xc8,0xc3,0xcb,0xed,
  1079.                5,
  1080.                10,255,4,255,0};
  1081.  
  1082.  
  1083. /* page with the 255 segment limit */
  1084. const int head1_5[] = {0x4f,0x67,0x67,0x53,0,0x02,
  1085.                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  1086.                0x01,0x02,0x03,0x04,0,0,0,0,
  1087.                0xff,0x7b,0x23,0x17,
  1088.                1,
  1089.                0};
  1090.  
  1091. const int head2_5[] = {0x4f,0x67,0x67,0x53,0,0x00,
  1092.                0x07,0xfc,0x03,0x00,0x00,0x00,0x00,0x00,
  1093.                0x01,0x02,0x03,0x04,1,0,0,0,
  1094.                0xed,0x2a,0x2e,0xa7,
  1095.                255,
  1096.                10,10,10,10,10,10,10,10,
  1097.                10,10,10,10,10,10,10,10,
  1098.                10,10,10,10,10,10,10,10,
  1099.                10,10,10,10,10,10,10,10,
  1100.                10,10,10,10,10,10,10,10,
  1101.                10,10,10,10,10,10,10,10,
  1102.                10,10,10,10,10,10,10,10,
  1103.                10,10,10,10,10,10,10,10,
  1104.                10,10,10,10,10,10,10,10,
  1105.                10,10,10,10,10,10,10,10,
  1106.                10,10,10,10,10,10,10,10,
  1107.                10,10,10,10,10,10,10,10,
  1108.                10,10,10,10,10,10,10,10,
  1109.                10,10,10,10,10,10,10,10,
  1110.                10,10,10,10,10,10,10,10,
  1111.                10,10,10,10,10,10,10,10,
  1112.                10,10,10,10,10,10,10,10,
  1113.                10,10,10,10,10,10,10,10,
  1114.                10,10,10,10,10,10,10,10,
  1115.                10,10,10,10,10,10,10,10,
  1116.                10,10,10,10,10,10,10,10,
  1117.                10,10,10,10,10,10,10,10,
  1118.                10,10,10,10,10,10,10,10,
  1119.                10,10,10,10,10,10,10,10,
  1120.                10,10,10,10,10,10,10,10,
  1121.                10,10,10,10,10,10,10,10,
  1122.                10,10,10,10,10,10,10,10,
  1123.                10,10,10,10,10,10,10,10,
  1124.                10,10,10,10,10,10,10,10,
  1125.                10,10,10,10,10,10,10,10,
  1126.                10,10,10,10,10,10,10,10,
  1127.                10,10,10,10,10,10,10};
  1128.  
  1129. const int head3_5[] = {0x4f,0x67,0x67,0x53,0,0x04,
  1130.                0x07,0x00,0x04,0x00,0x00,0x00,0x00,0x00,
  1131.                0x01,0x02,0x03,0x04,2,0,0,0,
  1132.                0x6c,0x3b,0x82,0x3d,
  1133.                1,
  1134.                50};
  1135.  
  1136.  
  1137. /* packet that overspans over an entire page */
  1138. const int head1_6[] = {0x4f,0x67,0x67,0x53,0,0x02,
  1139.                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  1140.                0x01,0x02,0x03,0x04,0,0,0,0,
  1141.                0xff,0x7b,0x23,0x17,
  1142.                1,
  1143.                0};
  1144.  
  1145. const int head2_6[] = {0x4f,0x67,0x67,0x53,0,0x00,
  1146.                0x07,0x04,0x00,0x00,0x00,0x00,0x00,0x00,
  1147.                0x01,0x02,0x03,0x04,1,0,0,0,
  1148.                0x3c,0xd9,0x4d,0x3f,
  1149.                17,
  1150.                100,255,255,255,255,255,255,255,255,
  1151.                255,255,255,255,255,255,255,255};
  1152.  
  1153. const int head3_6[] = {0x4f,0x67,0x67,0x53,0,0x01,
  1154.                0x07,0x04,0x00,0x00,0x00,0x00,0x00,0x00,
  1155.                0x01,0x02,0x03,0x04,2,0,0,0,
  1156.                0xbd,0xd5,0xb5,0x8b,
  1157.                17,
  1158.                255,255,255,255,255,255,255,255,
  1159.                255,255,255,255,255,255,255,255,255};
  1160.  
  1161. const int head4_6[] = {0x4f,0x67,0x67,0x53,0,0x05,
  1162.                0x07,0x10,0x00,0x00,0x00,0x00,0x00,0x00,
  1163.                0x01,0x02,0x03,0x04,3,0,0,0,
  1164.                0xef,0xdd,0x88,0xde,
  1165.                7,
  1166.                255,255,75,255,4,255,0};
  1167.  
  1168. /* packet that overspans over an entire page */
  1169. const int head1_7[] = {0x4f,0x67,0x67,0x53,0,0x02,
  1170.                0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  1171.                0x01,0x02,0x03,0x04,0,0,0,0,
  1172.                0xff,0x7b,0x23,0x17,
  1173.                1,
  1174.                0};
  1175.  
  1176. const int head2_7[] = {0x4f,0x67,0x67,0x53,0,0x00,
  1177.                0x07,0x04,0x00,0x00,0x00,0x00,0x00,0x00,
  1178.                0x01,0x02,0x03,0x04,1,0,0,0,
  1179.                0x3c,0xd9,0x4d,0x3f,
  1180.                17,
  1181.                100,255,255,255,255,255,255,255,255,
  1182.                255,255,255,255,255,255,255,255};
  1183.  
  1184. const int head3_7[] = {0x4f,0x67,0x67,0x53,0,0x05,
  1185.                0x07,0x08,0x00,0x00,0x00,0x00,0x00,0x00,
  1186.                0x01,0x02,0x03,0x04,2,0,0,0,
  1187.                0xd4,0xe0,0x60,0xe5,
  1188.                1,0};
  1189.  
  1190. void test_pack(const int *pl, const int **headers){
  1191.   unsigned char *data=_ogg_malloc(1024*1024); /* for scripted test cases only */
  1192.   long inptr=0;
  1193.   long outptr=0;
  1194.   long deptr=0;
  1195.   long depacket=0;
  1196.   long granule_pos=7,pageno=0;
  1197.   int i,j,packets,pageout=0;
  1198.   int eosflag=0;
  1199.   int bosflag=0;
  1200.  
  1201.   ogg_stream_reset(&os_en);
  1202.   ogg_stream_reset(&os_de);
  1203.   ogg_sync_reset(&oy);
  1204.  
  1205.   for(packets=0;;packets++)if(pl[packets]==-1)break;
  1206.  
  1207.   for(i=0;i<packets;i++){
  1208.     /* construct a test packet */
  1209.     ogg_packet op;
  1210.     int len=pl[i];
  1211.     
  1212.     op.packet=data+inptr;
  1213.     op.bytes=len;
  1214.     op.e_o_s=(pl[i+1]<0?1:0);
  1215.     op.granulepos=granule_pos;
  1216.  
  1217.     granule_pos+=1024;
  1218.  
  1219.     for(j=0;j<len;j++)data[inptr++]=i+j;
  1220.  
  1221.     /* submit the test packet */
  1222.     ogg_stream_packetin(&os_en,&op);
  1223.  
  1224.     /* retrieve any finished pages */
  1225.     {
  1226.       ogg_page og;
  1227.       
  1228.       while(ogg_stream_pageout(&os_en,&og)){
  1229.     /* We have a page.  Check it carefully */
  1230.  
  1231.     fprintf(stderr,"%ld, ",pageno);
  1232.  
  1233.     if(headers[pageno]==NULL){
  1234.       fprintf(stderr,"coded too many pages!\n");
  1235.       exit(1);
  1236.     }
  1237.  
  1238.     check_page(data+outptr,headers[pageno],&og);
  1239.  
  1240.     outptr+=og.body_len;
  1241.     pageno++;
  1242.  
  1243.     /* have a complete page; submit it to sync/decode */
  1244.  
  1245.     {
  1246.       ogg_page og_de;
  1247.       ogg_packet op_de,op_de2;
  1248.       char *buf=ogg_sync_buffer(&oy,og.header_len+og.body_len);
  1249.       memcpy(buf,og.header,og.header_len);
  1250.       memcpy(buf+og.header_len,og.body,og.body_len);
  1251.       ogg_sync_wrote(&oy,og.header_len+og.body_len);
  1252.  
  1253.       while(ogg_sync_pageout(&oy,&og_de)>0){
  1254.         /* got a page.  Happy happy.  Verify that it's good. */
  1255.         
  1256.         check_page(data+deptr,headers[pageout],&og_de);
  1257.         deptr+=og_de.body_len;
  1258.         pageout++;
  1259.  
  1260.         /* submit it to deconstitution */
  1261.         ogg_stream_pagein(&os_de,&og_de);
  1262.  
  1263.         /* packets out? */
  1264.         while(ogg_stream_packetpeek(&os_de,&op_de2)>0){
  1265.           ogg_stream_packetpeek(&os_de,NULL);
  1266.           ogg_stream_packetout(&os_de,&op_de); /* just catching them all */
  1267.           
  1268.           /* verify peek and out match */
  1269.           if(memcmp(&op_de,&op_de2,sizeof(op_de))){
  1270.         fprintf(stderr,"packetout != packetpeek! pos=%ld\n",
  1271.             depacket);
  1272.         exit(1);
  1273.           }
  1274.  
  1275.           /* verify the packet! */
  1276.           /* check data */
  1277.           if(memcmp(data+depacket,op_de.packet,op_de.bytes)){
  1278.         fprintf(stderr,"packet data mismatch in decode! pos=%ld\n",
  1279.             depacket);
  1280.         exit(1);
  1281.           }
  1282.           /* check bos flag */
  1283.           if(bosflag==0 && op_de.b_o_s==0){
  1284.         fprintf(stderr,"b_o_s flag not set on packet!\n");
  1285.         exit(1);
  1286.           }
  1287.           if(bosflag && op_de.b_o_s){
  1288.         fprintf(stderr,"b_o_s flag incorrectly set on packet!\n");
  1289.         exit(1);
  1290.           }
  1291.           bosflag=1;
  1292.           depacket+=op_de.bytes;
  1293.           
  1294.           /* check eos flag */
  1295.           if(eosflag){
  1296.         fprintf(stderr,"Multiple decoded packets with eos flag!\n");
  1297.         exit(1);
  1298.           }
  1299.  
  1300.           if(op_de.e_o_s)eosflag=1;
  1301.  
  1302.           /* check granulepos flag */
  1303.           if(op_de.granulepos!=-1){
  1304.         fprintf(stderr," granule:%ld ",(long)op_de.granulepos);
  1305.           }
  1306.         }
  1307.       }
  1308.     }
  1309.       }
  1310.     }
  1311.   }
  1312.   _ogg_free(data);
  1313.   if(headers[pageno]!=NULL){
  1314.     fprintf(stderr,"did not write last page!\n");
  1315.     exit(1);
  1316.   }
  1317.   if(headers[pageout]!=NULL){
  1318.     fprintf(stderr,"did not decode last page!\n");
  1319.     exit(1);
  1320.   }
  1321.   if(inptr!=outptr){
  1322.     fprintf(stderr,"encoded page data incomplete!\n");
  1323.     exit(1);
  1324.   }
  1325.   if(inptr!=deptr){
  1326.     fprintf(stderr,"decoded page data incomplete!\n");
  1327.     exit(1);
  1328.   }
  1329.   if(inptr!=depacket){
  1330.     fprintf(stderr,"decoded packet data incomplete!\n");
  1331.     exit(1);
  1332.   }
  1333.   if(!eosflag){
  1334.     fprintf(stderr,"Never got a packet with EOS set!\n");
  1335.     exit(1);
  1336.   }
  1337.   fprintf(stderr,"ok.\n");
  1338. }
  1339.  
  1340. int main(void){
  1341.  
  1342.   ogg_stream_init(&os_en,0x04030201);
  1343.   ogg_stream_init(&os_de,0x04030201);
  1344.   ogg_sync_init(&oy);
  1345.  
  1346.   /* Exercise each code path in the framing code.  Also verify that
  1347.      the checksums are working.  */
  1348.  
  1349.   {
  1350.     /* 17 only */
  1351.     const int packets[]={17, -1};
  1352.     const int *headret[]={head1_0,NULL};
  1353.     
  1354.     fprintf(stderr,"testing single page encoding... ");
  1355.     test_pack(packets,headret);
  1356.   }
  1357.  
  1358.   {
  1359.     /* 17, 254, 255, 256, 500, 510, 600 byte, pad */
  1360.     const int packets[]={17, 254, 255, 256, 500, 510, 600, -1};
  1361.     const int *headret[]={head1_1,head2_1,NULL};
  1362.     
  1363.     fprintf(stderr,"testing basic page encoding... ");
  1364.     test_pack(packets,headret);
  1365.   }
  1366.  
  1367.   {
  1368.     /* nil packets; beginning,middle,end */
  1369.     const int packets[]={0,17, 254, 255, 0, 256, 0, 500, 510, 600, 0, -1};
  1370.     const int *headret[]={head1_2,head2_2,NULL};
  1371.     
  1372.     fprintf(stderr,"testing basic nil packets... ");
  1373.     test_pack(packets,headret);
  1374.   }
  1375.  
  1376.   {
  1377.     /* large initial packet */
  1378.     const int packets[]={4345,259,255,-1};
  1379.     const int *headret[]={head1_3,head2_3,NULL};
  1380.     
  1381.     fprintf(stderr,"testing initial-packet lacing > 4k... ");
  1382.     test_pack(packets,headret);
  1383.   }
  1384.  
  1385.   {
  1386.     /* continuing packet test */
  1387.     const int packets[]={0,4345,259,255,-1};
  1388.     const int *headret[]={head1_4,head2_4,head3_4,NULL};
  1389.     
  1390.     fprintf(stderr,"testing single packet page span... ");
  1391.     test_pack(packets,headret);
  1392.   }
  1393.  
  1394.   /* page with the 255 segment limit */
  1395.   {
  1396.  
  1397.     const int packets[]={0,10,10,10,10,10,10,10,10,
  1398.            10,10,10,10,10,10,10,10,
  1399.            10,10,10,10,10,10,10,10,
  1400.            10,10,10,10,10,10,10,10,
  1401.            10,10,10,10,10,10,10,10,
  1402.            10,10,10,10,10,10,10,10,
  1403.            10,10,10,10,10,10,10,10,
  1404.            10,10,10,10,10,10,10,10,
  1405.            10,10,10,10,10,10,10,10,
  1406.            10,10,10,10,10,10,10,10,
  1407.            10,10,10,10,10,10,10,10,
  1408.            10,10,10,10,10,10,10,10,
  1409.            10,10,10,10,10,10,10,10,
  1410.            10,10,10,10,10,10,10,10,
  1411.            10,10,10,10,10,10,10,10,
  1412.            10,10,10,10,10,10,10,10,
  1413.            10,10,10,10,10,10,10,10,
  1414.            10,10,10,10,10,10,10,10,
  1415.            10,10,10,10,10,10,10,10,
  1416.            10,10,10,10,10,10,10,10,
  1417.            10,10,10,10,10,10,10,10,
  1418.            10,10,10,10,10,10,10,10,
  1419.            10,10,10,10,10,10,10,10,
  1420.            10,10,10,10,10,10,10,10,
  1421.            10,10,10,10,10,10,10,10,
  1422.            10,10,10,10,10,10,10,10,
  1423.            10,10,10,10,10,10,10,10,
  1424.            10,10,10,10,10,10,10,10,
  1425.            10,10,10,10,10,10,10,10,
  1426.            10,10,10,10,10,10,10,10,
  1427.            10,10,10,10,10,10,10,10,
  1428.            10,10,10,10,10,10,10,50,-1};
  1429.     const int *headret[]={head1_5,head2_5,head3_5,NULL};
  1430.     
  1431.     fprintf(stderr,"testing max packet segments... ");
  1432.     test_pack(packets,headret);
  1433.   }
  1434.  
  1435.   {
  1436.     /* packet that overspans over an entire page */
  1437.     const int packets[]={0,100,9000,259,255,-1};
  1438.     const int *headret[]={head1_6,head2_6,head3_6,head4_6,NULL};
  1439.     
  1440.     fprintf(stderr,"testing very large packets... ");
  1441.     test_pack(packets,headret);
  1442.   }
  1443.  
  1444.   {
  1445.     /* term only page.  why not? */
  1446.     const int packets[]={0,100,4080,-1};
  1447.     const int *headret[]={head1_7,head2_7,head3_7,NULL};
  1448.     
  1449.     fprintf(stderr,"testing zero data page (1 nil packet)... ");
  1450.     test_pack(packets,headret);
  1451.   }
  1452.  
  1453.  
  1454.  
  1455.   {
  1456.     /* build a bunch of pages for testing */
  1457.     unsigned char *data=_ogg_malloc(1024*1024);
  1458.     int pl[]={0,100,4079,2956,2057,76,34,912,0,234,1000,1000,1000,300,-1};
  1459.     int inptr=0,i,j;
  1460.     ogg_page og[5];
  1461.     
  1462.     ogg_stream_reset(&os_en);
  1463.  
  1464.     for(i=0;pl[i]!=-1;i++){
  1465.       ogg_packet op;
  1466.       int len=pl[i];
  1467.       
  1468.       op.packet=data+inptr;
  1469.       op.bytes=len;
  1470.       op.e_o_s=(pl[i+1]<0?1:0);
  1471.       op.granulepos=(i+1)*1000;
  1472.  
  1473.       for(j=0;j<len;j++)data[inptr++]=i+j;
  1474.       ogg_stream_packetin(&os_en,&op);
  1475.     }
  1476.  
  1477.     _ogg_free(data);
  1478.  
  1479.     /* retrieve finished pages */
  1480.     for(i=0;i<5;i++){
  1481.       if(ogg_stream_pageout(&os_en,&og[i])==0){
  1482.     fprintf(stderr,"Too few pages output building sync tests!\n");
  1483.     exit(1);
  1484.       }
  1485.       copy_page(&og[i]);
  1486.     }
  1487.  
  1488.     /* Test lost pages on pagein/packetout: no rollback */
  1489.     {
  1490.       ogg_page temp;
  1491.       ogg_packet test;
  1492.  
  1493.       fprintf(stderr,"Testing loss of pages... ");
  1494.  
  1495.       ogg_sync_reset(&oy);
  1496.       ogg_stream_reset(&os_de);
  1497.       for(i=0;i<5;i++){
  1498.     memcpy(ogg_sync_buffer(&oy,og[i].header_len),og[i].header,
  1499.            og[i].header_len);
  1500.     ogg_sync_wrote(&oy,og[i].header_len);
  1501.     memcpy(ogg_sync_buffer(&oy,og[i].body_len),og[i].body,og[i].body_len);
  1502.     ogg_sync_wrote(&oy,og[i].body_len);
  1503.       }
  1504.  
  1505.       ogg_sync_pageout(&oy,&temp);
  1506.       ogg_stream_pagein(&os_de,&temp);
  1507.       ogg_sync_pageout(&oy,&temp);
  1508.       ogg_stream_pagein(&os_de,&temp);
  1509.       ogg_sync_pageout(&oy,&temp);
  1510.       /* skip */
  1511.       ogg_sync_pageout(&oy,&temp);
  1512.       ogg_stream_pagein(&os_de,&temp);
  1513.  
  1514.       /* do we get the expected results/packets? */
  1515.       
  1516.       if(ogg_stream_packetout(&os_de,&test)!=1)error();
  1517.       checkpacket(&test,0,0,0);
  1518.       if(ogg_stream_packetout(&os_de,&test)!=1)error();
  1519.       checkpacket(&test,100,1,-1);
  1520.       if(ogg_stream_packetout(&os_de,&test)!=1)error();
  1521.       checkpacket(&test,4079,2,3000);
  1522.       if(ogg_stream_packetout(&os_de,&test)!=-1){
  1523.     fprintf(stderr,"Error: loss of page did not return error\n");
  1524.     exit(1);
  1525.       }
  1526.       if(ogg_stream_packetout(&os_de,&test)!=1)error();
  1527.       checkpacket(&test,76,5,-1);
  1528.       if(ogg_stream_packetout(&os_de,&test)!=1)error();
  1529.       checkpacket(&test,34,6,-1);
  1530.       fprintf(stderr,"ok.\n");
  1531.     }
  1532.  
  1533.     /* Test lost pages on pagein/packetout: rollback with continuation */
  1534.     {
  1535.       ogg_page temp;
  1536.       ogg_packet test;
  1537.  
  1538.       fprintf(stderr,"Testing loss of pages (rollback required)... ");
  1539.  
  1540.       ogg_sync_reset(&oy);
  1541.       ogg_stream_reset(&os_de);
  1542.       for(i=0;i<5;i++){
  1543.     memcpy(ogg_sync_buffer(&oy,og[i].header_len),og[i].header,
  1544.            og[i].header_len);
  1545.     ogg_sync_wrote(&oy,og[i].header_len);
  1546.     memcpy(ogg_sync_buffer(&oy,og[i].body_len),og[i].body,og[i].body_len);
  1547.     ogg_sync_wrote(&oy,og[i].body_len);
  1548.       }
  1549.  
  1550.       ogg_sync_pageout(&oy,&temp);
  1551.       ogg_stream_pagein(&os_de,&temp);
  1552.       ogg_sync_pageout(&oy,&temp);
  1553.       ogg_stream_pagein(&os_de,&temp);
  1554.       ogg_sync_pageout(&oy,&temp);
  1555.       ogg_stream_pagein(&os_de,&temp);
  1556.       ogg_sync_pageout(&oy,&temp);
  1557.       /* skip */
  1558.       ogg_sync_pageout(&oy,&temp);
  1559.       ogg_stream_pagein(&os_de,&temp);
  1560.  
  1561.       /* do we get the expected results/packets? */
  1562.       
  1563.       if(ogg_stream_packetout(&os_de,&test)!=1)error();
  1564.       checkpacket(&test,0,0,0);
  1565.       if(ogg_stream_packetout(&os_de,&test)!=1)error();
  1566.       checkpacket(&test,100,1,-1);
  1567.       if(ogg_stream_packetout(&os_de,&test)!=1)error();
  1568.       checkpacket(&test,4079,2,3000);
  1569.       if(ogg_stream_packetout(&os_de,&test)!=1)error();
  1570.       checkpacket(&test,2956,3,4000);
  1571.       if(ogg_stream_packetout(&os_de,&test)!=-1){
  1572.     fprintf(stderr,"Error: loss of page did not return error\n");
  1573.     exit(1);
  1574.       }
  1575.       if(ogg_stream_packetout(&os_de,&test)!=1)error();
  1576.       checkpacket(&test,300,13,14000);
  1577.       fprintf(stderr,"ok.\n");
  1578.     }
  1579.     
  1580.     /* the rest only test sync */
  1581.     {
  1582.       ogg_page og_de;
  1583.       /* Test fractional page inputs: incomplete capture */
  1584.       fprintf(stderr,"Testing sync on partial inputs... ");
  1585.       ogg_sync_reset(&oy);
  1586.       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
  1587.          3);
  1588.       ogg_sync_wrote(&oy,3);
  1589.       if(ogg_sync_pageout(&oy,&og_de)>0)error();
  1590.       
  1591.       /* Test fractional page inputs: incomplete fixed header */
  1592.       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+3,
  1593.          20);
  1594.       ogg_sync_wrote(&oy,20);
  1595.       if(ogg_sync_pageout(&oy,&og_de)>0)error();
  1596.       
  1597.       /* Test fractional page inputs: incomplete header */
  1598.       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+23,
  1599.          5);
  1600.       ogg_sync_wrote(&oy,5);
  1601.       if(ogg_sync_pageout(&oy,&og_de)>0)error();
  1602.       
  1603.       /* Test fractional page inputs: incomplete body */
  1604.       
  1605.       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+28,
  1606.          og[1].header_len-28);
  1607.       ogg_sync_wrote(&oy,og[1].header_len-28);
  1608.       if(ogg_sync_pageout(&oy,&og_de)>0)error();
  1609.       
  1610.       memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,1000);
  1611.       ogg_sync_wrote(&oy,1000);
  1612.       if(ogg_sync_pageout(&oy,&og_de)>0)error();
  1613.       
  1614.       memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body+1000,
  1615.          og[1].body_len-1000);
  1616.       ogg_sync_wrote(&oy,og[1].body_len-1000);
  1617.       if(ogg_sync_pageout(&oy,&og_de)<=0)error();
  1618.       
  1619.       fprintf(stderr,"ok.\n");
  1620.     }
  1621.  
  1622.     /* Test fractional page inputs: page + incomplete capture */
  1623.     {
  1624.       ogg_page og_de;
  1625.       fprintf(stderr,"Testing sync on 1+partial inputs... ");
  1626.       ogg_sync_reset(&oy); 
  1627.  
  1628.       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
  1629.          og[1].header_len);
  1630.       ogg_sync_wrote(&oy,og[1].header_len);
  1631.  
  1632.       memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
  1633.          og[1].body_len);
  1634.       ogg_sync_wrote(&oy,og[1].body_len);
  1635.  
  1636.       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
  1637.          20);
  1638.       ogg_sync_wrote(&oy,20);
  1639.       if(ogg_sync_pageout(&oy,&og_de)<=0)error();
  1640.       if(ogg_sync_pageout(&oy,&og_de)>0)error();
  1641.  
  1642.       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+20,
  1643.          og[1].header_len-20);
  1644.       ogg_sync_wrote(&oy,og[1].header_len-20);
  1645.       memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
  1646.          og[1].body_len);
  1647.       ogg_sync_wrote(&oy,og[1].body_len);
  1648.       if(ogg_sync_pageout(&oy,&og_de)<=0)error();
  1649.  
  1650.       fprintf(stderr,"ok.\n");
  1651.     }
  1652.     
  1653.     /* Test recapture: garbage + page */
  1654.     {
  1655.       ogg_page og_de;
  1656.       fprintf(stderr,"Testing search for capture... ");
  1657.       ogg_sync_reset(&oy); 
  1658.       
  1659.       /* 'garbage' */
  1660.       memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
  1661.          og[1].body_len);
  1662.       ogg_sync_wrote(&oy,og[1].body_len);
  1663.  
  1664.       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
  1665.          og[1].header_len);
  1666.       ogg_sync_wrote(&oy,og[1].header_len);
  1667.  
  1668.       memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
  1669.          og[1].body_len);
  1670.       ogg_sync_wrote(&oy,og[1].body_len);
  1671.  
  1672.       memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header,
  1673.          20);
  1674.       ogg_sync_wrote(&oy,20);
  1675.       if(ogg_sync_pageout(&oy,&og_de)>0)error();
  1676.       if(ogg_sync_pageout(&oy,&og_de)<=0)error();
  1677.       if(ogg_sync_pageout(&oy,&og_de)>0)error();
  1678.  
  1679.       memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header+20,
  1680.          og[2].header_len-20);
  1681.       ogg_sync_wrote(&oy,og[2].header_len-20);
  1682.       memcpy(ogg_sync_buffer(&oy,og[2].body_len),og[2].body,
  1683.          og[2].body_len);
  1684.       ogg_sync_wrote(&oy,og[2].body_len);
  1685.       if(ogg_sync_pageout(&oy,&og_de)<=0)error();
  1686.  
  1687.       fprintf(stderr,"ok.\n");
  1688.     }
  1689.  
  1690.     /* Test recapture: page + garbage + page */
  1691.     {
  1692.       ogg_page og_de;
  1693.       fprintf(stderr,"Testing recapture... ");
  1694.       ogg_sync_reset(&oy); 
  1695.  
  1696.       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
  1697.          og[1].header_len);
  1698.       ogg_sync_wrote(&oy,og[1].header_len);
  1699.  
  1700.       memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
  1701.          og[1].body_len);
  1702.       ogg_sync_wrote(&oy,og[1].body_len);
  1703.  
  1704.       memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header,
  1705.          og[2].header_len);
  1706.       ogg_sync_wrote(&oy,og[2].header_len);
  1707.  
  1708.       memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header,
  1709.          og[2].header_len);
  1710.       ogg_sync_wrote(&oy,og[2].header_len);
  1711.  
  1712.       if(ogg_sync_pageout(&oy,&og_de)<=0)error();
  1713.  
  1714.       memcpy(ogg_sync_buffer(&oy,og[2].body_len),og[2].body,
  1715.          og[2].body_len-5);
  1716.       ogg_sync_wrote(&oy,og[2].body_len-5);
  1717.  
  1718.       memcpy(ogg_sync_buffer(&oy,og[3].header_len),og[3].header,
  1719.          og[3].header_len);
  1720.       ogg_sync_wrote(&oy,og[3].header_len);
  1721.  
  1722.       memcpy(ogg_sync_buffer(&oy,og[3].body_len),og[3].body,
  1723.          og[3].body_len);
  1724.       ogg_sync_wrote(&oy,og[3].body_len);
  1725.  
  1726.       if(ogg_sync_pageout(&oy,&og_de)>0)error();
  1727.       if(ogg_sync_pageout(&oy,&og_de)<=0)error();
  1728.  
  1729.       fprintf(stderr,"ok.\n");
  1730.     }
  1731.   }    
  1732.  
  1733.   return(0);
  1734. }
  1735.  
  1736. #endif
  1737.  
  1738.  
  1739.  
  1740.  
  1741.